Method and system for providing multiple levels of help information for a computer program

ABSTRACT

A method and system for providing help information for a computer program. The help system provides help information based on a schema that specifies the structure of a valid computer program. The schema provides definitions of program element types that are specific instances of a program element type derived from more general program element types. The help system identifies a “derivation” of program element types relating to the selected program element. The help system then displays the derivation to the user. The user can then select to display documentation associated with the displayed program element types.

CROSS-REFERENCE TO RELATED APPLICATIONS

This is a continuation application of U.S. patent application Ser. No.11/353,224, filed Feb. 13, 2006, which is a continuation application ofU.S. patent application Ser. No. 10/616,293, filed Jul. 8, 2003, nowU.S. Pat. No. 7,051,279, issued May 23, 2006, each of which is hereinincorporated by reference in its entirety.

TECHNICAL FIELD

The described technology relates generally to providing help informationfor a computer program.

BACKGROUND

Computer programs are generally written in a high-level programminglanguage (e.g., Java or C). Compilers are then used to translate theinstructions of the high-level programming language into machineinstructions that can be executed by a computer. The compilation processis generally divided into six phases:

1. Lexical analysis

2. Syntactic analysis

3. Semantic analysis

4. Intermediate code generation

5. Code optimization

6. Final code generation

During lexical analysis, the source code of the computer program isscanned and components or tokens of the high-level language areidentified. The compiler then converts the source code into a series oftokens that can be processed during syntactic analysis. For example,during lexical analysis, the compiler would identify the statement

cTable=1.0;

as the variable (cTable), the operator(=), the constant (1.0), and asemicolon. A variable, operator, constant, and semicolon are tokens ofthe high-level language.

During syntactic analysis (also referred to as “parsing”), the compilerprocesses the tokens and generates a syntax tree to represent theprogram based on the syntax (also referred to as “grammar”) of theprogramming language. A syntax tree is a tree structure in whichoperators are represented by non-leaf nodes and their operands arerepresented by child nodes. In the above example, the operator (=) hastwo operands: the variable (cTable) and the constant (1.0). The terms“parse tree” and “syntax tree” are used interchangeably in thisdescription to refer to the syntax-based tree generated as a result ofsyntactic analysis. For example, such a tree optionally may describe thederivation of the syntactic structure of the computer program (e.g., itmay describe that a certain token is an identifier, which is anexpression as defined by the syntax). Syntax-based trees may also bereferred to as “concrete syntax trees” when the derivation of thesyntactic structure is included, and as “abstract syntax trees” when thederivation is not included.

During semantic analysis, the compiler modifies the syntax tree toensure semantic correctness. For example, if the variable (cTable) is aninteger and the constant (1.0) is a floating-point, then during semanticanalysis a floating point to integer conversion would be added to thesyntax tree.

During intermediate code generation, code optimization, and final codegeneration, the compiler generates machine instructions to implement theprogram represented by the syntax tree. A computer can then execute themachine instructions.

A system has been described for generating and maintaining a computerprogram represented as an intentional program tree, which is a type ofsyntax tree. (For example, U.S. Pat. No. 5,790,863 entitled “Method andSystem for Generating and Displaying a Computer Program” and U.S. Pat.No. 6,097,888 entitled “Method and System for Reducing an IntentionalProgram Tree Represented by High-Level Computational Constructs,” bothof which are hereby incorporated by reference.) The system provides amechanism for directly manipulating nodes corresponding to “programelements” by adding, deleting, and moving the nodes within anintentional program tree. An intentional program tree is one type of“program tree.” A “program tree” is a tree representation of a computerprogram that includes operator nodes and operand nodes representingprogram elements. A program tree may also include inter-node references(i.e., graph structures linking nodes in the tree), such as a referencefrom a declaration node of an identifier to the node that defines thatidentifier's program element type. An abstract syntax tree and aconcrete syntax tree are examples of a program tree. Once a program treeis generated, the system performs the steps of semantic analysis,intermediate code generation, code optimization, and final codegeneration to the transformation of the computer program represented bythe program tree into executable code.

FIG. 1 is a diagram illustrating a portion of a program treecorresponding to the definition of a method. The method is defined bythe following:

public static int increment (int i){i++; return i;}

Node 101 corresponds to the root of the sub-tree of the program treerepresenting the “increment” method. Nodes 102-108 are child nodes ofthe root node. Nodes 109 and 110 are child nodes of node 106, node 111is a child node of node 107, and node 112 is a child node of node 108.Each node has a reference to another node in the program tree thatdefines the node type. For example, node 107 references a declarationnode that defines a “statement,” and node 111 references (indicated bythe dashed line) node 106 for the parameter “i.” Such referenced nodesare also referred to as declaration definitions.

Various editing facilities provide a “context-sensitive help” capabilityfor a computer program. The information used to provide the help may beassociated with the nodes of a program tree as comments, remarks,summaries, help information, to-do items, or other documentation. Suchdocumentation may be stored as an attribute of a node. A programmer mayspecify such documentation for various nodes of a program tree duringprogram development. When a programmer selects a node, an editingfacility may display a list of help topics that are appropriate for theselected node (i.e., the editing facility is context-sensitive). Forexample, if the selected node represents a Java method call, then theediting facility may display an indication of programmer-specifiedremarks and an indication of system-defined documentation for a Javamethod call as help topics. The programmer-specified remarks maydescribe why the Java method is being called, and the system-definedremarks may describe the syntax and semantics of a Java method callsemantics. When the programmer selects a help topic, the editingfacility displays the associated documentation.

Although the editing facilities provide context-sensitive help, the helpinformation may not include all the information that a programmer mayneed. For example, the help information associated with Java method calltype may describe the details of the Java syntax of a method call. Aprogrammer may, however, need more general information, such as what isan object-oriented method call or what is a function call. It would bedesirable to have a help system that would provide more flexibility inselecting the desired level of detail of help information that isprovided.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram illustrating a portion of a program treecorresponding to the definition of a method.

FIG. 2 is a diagram illustrating a portion of a program tree that showsa sample user project and sample schemas in one embodiment.

FIG. 3 is a block diagram illustrating components of the editing systemin one embodiment.

FIG. 4 is a display page that illustrates the display of a derivationrelating to a selected program element in one embodiment.

FIG. 5 is a flow diagram illustrating the processing of the helpcomponent in one embodiment.

FIG. 6 is a flow diagram illustrating the processing of the identifyderivation component in one embodiment.

DETAILED DESCRIPTION

A method and system for providing help information for a computerprogram is provided. In one embodiment, the help system provides helpinformation based on a schema that specifies the structure of a validcomputer program. The schema provides definitions of program elementtypes that are specific instances of a program element type derived frommore general program element types. For example, a program element typemay be “a Java method call,” which is a specific instance of the moregeneral program element type “object-oriented method call.” The programelement types have associated help information that may besystem-defined or user-defined. The help system provides helpinformation for a computer program that is defined by program elementshaving a program element type. For example, a statement that is a callto a method may have the program element type of “a Java method call.”The help system receives from the user a selection of a program elementof the computer program for which help information is desired. The helpsystem identifies a “program element type derivation” of program elementtypes relating to the selected program element. A “program element typederivation” is a list of increasingly more general program element typesthat define the current type. For example, the derivation of a methodcall program element would include the “Java method call” and“object-oriented method call” program element types. The help systemthen displays the derivation to the user. When the user selects aprogram element type from the displayed derivation, the help systemretrieves the help information associated with the selected programelement type. The help system then displays the retrieved helpinformation to the user. In this way, a user can select help informationrelating to a program element at various levels of generalization.

In one embodiment, a computer program is represented as a program tree,and the program element types are defined via “isa” relationshipsbetween nodes. The program element types may be predefined in a schemaor defined as part of the computer program. For example, a “Java methodcall” may be a predefined program element type, and the declaration of acertain variable in the computer program may be a user-defined programelement type. Thus, nodes within the program tree may have isarelationships with nodes representing the computer program or with nodeswithin schemas. The isa relationships define an ancestor-and-descendentrelationship in that the “Java method call” program element type is adescendent of an “object-oriented method call” program element type, andthe “object-oriented method call” program element type is an ancestor ofthe “Java method call” program element type. Each ancestor programelement type may represent an increasing level of generalization orabstraction of program element types. These increasing levels ofgeneralization define a chain of program element types (i.e., aderivation).

In an alternate embodiment, the help system provides help informationassociated with other types of derivations and derivations for relatedprogram elements. A derivation can be based on a programmaticrelationship, which may include a derivation based on the organizationof the computer program, referred to as a “program tree derivation.” Forexample, a statement within a method may have a derivation that includesthe class definition in which the method is defined, the module thatcontains the class definition, and the project that contains the module.This derivation may be defined by the hierarchical relationship amongthe operators and operands of a program tree. The related programelements include ancestor program elements, sibling program elements,and descendant program elements. For example, the related programelements of an actual parameter of a method invocation may be the otherparameters of the method invocation and the method invocation itself.In, such a case, the help system may provide help information related tothe actual parameter, the other parameters, and the method invocationprogram tree elements. The help information may be provided for theprogram elements themselves and help associated with their programelement type derivations and program tree derivations. As anotherexample of a derivation, program trees may represent different levels ofabstraction of a computer program. The levels of abstraction may includea design-level specification of the behavior of a computer program(e.g., a design document) and an instruction set specific level of thecomputer program. Each program tree represents a more concreterepresentation of the next higher level of abstraction. The programelements for a program tree at one level of abstraction may referencetheir corresponding program elements of the program tree at the nexthigher level of abstraction. These levels of abstraction are referred toas “program tree abstraction derivations.” For example, a program treethat defines the structure of a user interface may specify a dialog boxat one level of abstraction that is defined as list box and then adrop-down list box at lower levels of abstraction. The program elementfor drop-down list box may have a child program element that specifiesthe font for the choices within the drop-down list box. When the helpsystem provides help information for the drop-down list box programelement, it may provide help information associated with the fontspecified by the child program element and with the program element typederivation that may include information describing a font generally. Thehelp system may also provide help information associated with theprogram tree derivation (e.g., list box and dialog box) of the drop-downlist box.

FIG. 2 is a diagram illustrating a portion of a program tree 240 thatshows a sample user project and sample schemas in one embodiment. Theprogram tree 240 includes a user project or program subtree 250 andschema subtrees 260. The schema subtrees include subtrees 270, 280, and290, which may be a standard part of each program tree that represents aJava computer program. The root of the program tree is represented bynode 241. The user project subtree 250 includes nodes 251-254, whichrepresent program elements for a portion of the following code:

class MyWriter {  void write(byte i) {   writeByte(i);  }  voidwriteByte(int i) { ... }  ... }Schema subtree 290 specifies the structure of a valid program tree thatmay be common to any programming language. Schema subtree 280 specifiesthe structure of a valid program tree that may be common to anyobject-oriented programming language. Schema subtree 270 specifies thestructure of a valid program tree for the Java programming language. Forexample, node 282 specifies that a program tree representing a computerprogram in an object-oriented programming language can have a node thatis a node type or program element type of “00.” In addition, nodes 283,284, and 285 indicate that a node with a node type or program elementtype of “00” can have child nodes with node types of “00 memberfunction,” “00 data member,” and “00 supertype,” respectively. Eachchild node also may specify the number of occurrences of a node of thatnode type that is allowed in a valid program tree. For example, “0 . . .N” means that there may be zero or more Occurrences, “0 . . . 1” meansthat there may be zero or one occurrence, “1” means that there must beonly one occurrence, etc. The child nodes in one embodiment mayrepresent the possible categories of a node of the parent node type. Forexample, a node of node type “Java class” in a program tree can havechild nodes with the categories of “Java method,” “Java field,” or“superclass,” as indicated by nodes 274, 275, and 276. Each node of aprogram tree may have its node type defined by a reference to a nodewithin a schema. For example, user program nodes 252, 253, and 254reference schema nodes 272, 274, and 274, respectively. Each schemarepresents a certain level of abstraction defining a valid computerprogram. In this example, schema subtree 290 represents an abstractionof schema subtree 280, which in turn represents an abstraction of schemasubtree 270. Each node of a schema subtree may have a reference to thecorresponding node in the next higher level of abstraction. For example,node 276 (corresponding to a “superclass” node type for the Javaprogramming language) has a reference to node 285 (corresponding to the“supertype” node type for an object-oriented programming language), asindicated by the dashed line 277. Each node may represent a structurecontaining information (e.g., documentation or help information)relating to the node type of the node. The references between nodesrepresented by the dashed lines are referred to as “isa” relationships.Each isa relationship may be considered to extend the structure of thereferenced node. For example, node 276 (with a node type of“superclass”) has an isa relationship with node 285 (with a node type of“supertype”). Node 285 may have documentation that describes the“supertype” node type generically, while node 276 may have documentationthat describes the Java “superclass” node type specifically, effectivelyextending the documentation of node 285.

FIG. 3 is a block diagram illustrating components of an editing system300 in one embodiment. The editing system 300 may include a program treeeditor 301, an update program tree component 302, a display program treecomponent 303, and a help component 304. The program tree editor invokesthe update program tree component when the programmer has indicated tomake a modification (e.g., add a node) to the program tree. The programtree editor invokes the display program tree component to update thedisplay of the program tree. The system also includes a program treestore 305. The program tree store contains the program tree, includingthe schemas currently being modified by the program tree editor. Thehelp component is invoked when a user has selected a program element andhas requested help. The help component generates and displays thederivation for the selected program element. When a programmer selects aprogram element type from the displayed derivation, the help componentdisplays help information associated with the selected program elementtype.

The help system may be implemented on a computer system that includes acentral processing unit, memory, input devices (e.g., keyboard andpointing devices), output devices (e.g., display devices), and storagedevices (e.g., disk drives). The memory and storage devices arecomputer-readable media that may contain instructions that implement thehelp system. In addition, the data structures and message structures maybe stored or transmitted via a data transmission medium such as a signalon a communications link. Various communications links may be used, suchas the Internet, a local area network, a wide area network, or apoint-to-point dial-up connection.

FIG. 4 is a display page that illustrates the display of a derivationfor a selected program element in one embodiment. The display page 400includes a display representation 401 of a portion of a program treerepresenting the MyWriter class 252 (see FIG. 2). In this example, theprogrammer has selected the name of the writeByte method 402 in the callstatement within the definition of the write method. The programmer thenindicated to display help information associated with the selectedmethod. In response, the help system identified the program element typederivation of the writeByte method definition. The writeByte methoddefinition corresponds to node 254 of the program tree (FIG. 2).Referring back to FIG. 2, although the subtree representing thestatement is not shown, it has a node corresponding to the name“writeByte” that has an isa relationship with node 254. Node 254 has anisa relationship with the “Java method” program element type representedby node 274. Node 274 has an isa relationship with the “00 memberfunction” program element type represented by node 283. Node 283 has anisa relationship with the “definition” program element type representedby node 292. Thus, the derivation for the selected program elementincludes node 254, node 274, and node 283. Returning to FIG. 4, the helpsystem may generate a display list 403 by retrieving a name attributeassociated with each node in the derivation. When the programmer selectsa name from the display list, the help system retrieves thedocumentation or other help information associated with thecorresponding node. For example, if the programmer selects the “Javamethod” program element type from the display list, then the systemretrieves documentation associated with node 274 (FIG. 2), which may bestored as an attribute of the node, and displays it to the programmer.The “statement” in the display list corresponds to the selected programelement and is, strictly speaking, not considered part of thederivation. When the programmer selects the “statement” from the displaylist, the help system displays user-defined help information that isassociated with the selected program element. Alternatively, rather thandisplaying the display list, the help system can retrieve thedocumentation from each node in the list and display it.

FIG. 5 is a flow diagram illustrating the processing of the helpcomponent in one embodiment. The component is passed an indication ofthe currently selected program element and displays a list containingthe program element type derivation of the selected program element andhelp information when the programmer selects an entry (e.g., programelement type) from the display list. In block 501, the component invokesthe identify derivation component to identify the derivation of thepassed program element. In blocks 502-504, the component loops,identifying the ancestor nodes of the passed program element. Thecomponent may also add an entry to the display list corresponding to thepassed program element. One skilled in the art will appreciate thatentries corresponding to other program elements may be added to thedisplay list. For example, entries corresponding to the parent node orsibling nodes of the passed program element within the program tree maybe added to the display list. In block 502, the component selects thenext node in the derivation. In decision block 503, if all the nodes inthe derivation have already been selected, then the component continuesat block 505, else of the component continues at block 504. In block504, the component adds the name of the selected node to the displaylist and loops to block 502 to select the next node in the derivation.In block 505, the component displays the display list to the programmer.In block 506, the component receives a selection of a program elementtype from the displayed list. In block 507, the component retrieves helpinformation associated with the selected program element type. In block508, the component displays the retrieved help information and thenreturns.

FIG. 6 is a flow diagram illustrating the processing of the identifyderivation component in one embodiment. The component is passed aprogram element and returns the program element type derivation for thatprogram element. In block 601, the component sets the current node tothe passed program element. In blocks 602-604, the component loops,selecting each ancestor node of the passed program element and adding itto the derivation. In decision block 602, if the program element type ofthe current node is null, the component is at the end of the derivationand returns, else the component continues at block 603. In block 603,the component adds the program element type of the current node to thederivation. In block 604, the component sets the current node to theprogram element type of the current node and then loops to block 602 todetermine whether the end of the derivation has been reached.

One skilled in the art will appreciate that although specificembodiments of the help system have been described herein for purposesof illustration, various modifications may be made without deviatingfrom the spirit and scope of the invention. For example, one skilled inthe art could adapt the described help system to provide helpinformation for the derivation of any type of programmatic relationshipand for any type of related program elements. The related programelements can be defined on a program element type basis. For example,the related program elements to an actual parameter could be the otheractual parameter (i.e., sibling program elements) and to a method couldbe its enclosing class (i.e., program element). Accordingly, theinvention is defined by the appended claims.

1. A method performed by a computer having a memory and a processor forproviding information for a program subtree, the method comprising:providing a structure of element types specifying relationships betweenthe element types; providing a program subtree having program elements,each program element having an element type, wherein the structure ofelement types is not part of the program subtree; and with a processor,identifying, based on the structure of element types, at least oneelement type that is related to an element type of a first element ofthe provided program subtree.
 2. The method of claim 1, furthercomprising: displaying an indication of the identified at least oneelement type, including naming information associated with theidentified at least one element type.
 3. The method of claim 1 whereininformation associated with a first element type is stored as anattribute of a node representing the first element type.
 4. The methodof claim 1 wherein element types are stored in schemas defining validprogram trees at different levels of abstraction.
 5. The method of claim4 wherein a schema is represented as a tree data structure.
 6. Themethod of claim 4 wherein each element type is represented as a nodewithin a type tree.
 7. The method of claim 1 wherein a related elementtype may be any of an ancestor element type, a sibling element type, ora descendant element type.
 8. The method of claim 7 wherein eachancestor element type is specified by an is a relationship.
 9. Acomputer-readable medium containing instructions that, when executed bya computer having a memory and a processor, cause the computer toperform a method for controlling a computer system to provideinformation for a tree, the method comprising: providing a plurality ofelement types that are specific instances of more general element types,each element type having associated information; providing a tree havingelements, each element of the tree having an element type of theprovided plurality of elements types, wherein the plurality of elementtypes is stored separately from the tree; based at least in part on theplurality of element types, identifying a derivation of an element typeof a selected element of the provided tree, the derivation representingmore general element types of the element type of the selected element;and displaying information associated with at least one element type ofthe identified derivation.
 10. The computer-readable medium of claim 9wherein the identifying of a derivation is performed in response to auser selecting an element of the tree.
 11. The computer-readable mediumof claim 9 wherein the information associated with an element type isstored as an attribute of the element type.
 12. The computer-readablemedium of claim 9 wherein an element type is stored as a definitionwithin a type tree.
 13. The computer-readable medium of claim 9 whereinthe displayed information is help information.
 14. The computer-readablemedium of claim 9 wherein the plurality of element types are organizedaccording to a schema.
 15. The computer-readable medium of claim 14wherein the schema specifies a structure of a valid computer program.16. The computer-readable medium of claim 14 wherein the schema providesdefinitions of program element types related to other program elementtypes.
 17. A system having a memory and a processor for providinginformation for a tree structure, the system comprising: a schemaspecifying a structure of a valid computer program, the schema providingdefinitions of program element types related to other program elementtypes; a component that receives from a user a selection of a programelement of a computer program, the computer program having a pluralityof program elements; a component that, based at least in part on theschema, identifies at least one program element type related to theselected program element; a component that retrieves informationassociated with the identified at least one program element typesrelated to the selected program element; and a component that displaysthe retrieved information wherein at least one of the componentscomprises computer-executable instructions stored in memory forexecution by the system.
 18. The system of claim 17, further comprising:a component that identifies element types related to the selectedelement type.
 19. The system of claim 18 wherein the component thatdisplays the retrieved information displays naming informationassociated with the related element types.
 20. The system of claim 18wherein the related elements include ancestor elements, siblingelements, and descendant elements.
 21. The computer-readable medium ofclaim 9, wherein identifying the derivation of the element type of theselected element of the provided tree comprises: determining a firstelement type of the selected element of the provided tree; adding thefirst element type of the selected element of the provided tree to thederivation; identifying a first node corresponding to the first elementtype of the selected element of the provided tree, wherein the firstnode is not part of the provided tree; determining a second element typeof the identified first node; adding the second element type of theidentified first node to the derivation; and identifying a second nodecorresponding to the second element type of the identified first node,wherein the second node is not part of the provided tree.
 22. Thecomputer-readable medium of claim 21, wherein identifying the derivationof the element type of the selected element of the provided treecomprises: determining a third element type of the identified secondnode; adding the third element type of the identified second node to thederivation; and identifying a third node corresponding to the thirdelement type of the identified second node, wherein the third node isnot part of the provided tree.